// #include <stdio.h>
// #include <stdlib.h>
// #include <math.h>

// // 贪心验证：判断是否能通过不超过k次操作，让所有相邻差≤mid
// int isPossible(int *a, int n, int k, int mid) {
//     int count = 0;  // 已使用的操作次数
//     int prev = a[0];  // 前一朵花的漂亮度（可能被替换后的值）
    
//     for (int i = 1; i < n; ++i) {
//         int diff = abs(a[i] - prev);
//         if (diff > mid) {
//             // 需要替换当前花（a[i]），操作次数+1
//             count++;
//             // 贪心替换：让当前花的漂亮度=prev（或prev±mid，效果一致），最小化后续差值
//             prev = prev;  // 等价于将a[i]改为prev，后续以prev为基准
//             // 若操作次数超过k，直接返回不可行
//             if (count > k) {
//                 return 0;
//             }
//         } else {
//             // 无需替换，更新前一朵花为当前花的原始值
//             prev = a[i];
//         }
//     }
//     return count <= k;  // 总操作次数≤k则可行
// }

// // 计算初始最大相邻差（二分的上界）
// int getInitialMaxDiff(int *a, int n) {
//     int maxDiff = 0;
//     for (int i = 1; i < n; ++i) {
//         int diff = abs(a[i] - a[i-1]);
//         if (diff > maxDiff) {
//             maxDiff = diff;
//         }
//     }
//     return maxDiff;
// }

// int main() {
//     int n, k;
//     scanf("%d %d", &n, &k);
    
//     int *a = (int *)malloc(n * sizeof(int));
//     for (int i = 0; i < n; ++i) {
//         scanf("%d", &a[i]);
//     }
    
//     // 特殊情况：n≤2时，可通过替换让凌乱度为0（k≥1）
//     if (n <= 2) {
//         printf("0\n");
//         free(a);
//         return 0;
//     }
    
//     int low = 0;
//     int high = getInitialMaxDiff(a, n);
//     int ans = high;  // 初始答案设为最大可能值
    
//     // 二分答案
//     while (low <= high) {
//         int mid = low + (high - low) / 2;  // 避免溢出
//         if (isPossible(a, n, k, mid)) {
//             ans = mid;  // mid可行，尝试更小的可能
//             high = mid - 1;
//         } else {
//             low = mid + 1;  // mid不可行，需要更大的mid
//         }
//     }
    
//     printf("%d\n", ans);
//     free(a);
//     return 0;
// }


// #include <stdio.h>
// #include <string.h>

// // 方向定义：0=右，1=下，2=左，3=上（初始方向为0）
// int dx[] = {0, 1, 0, -1};
// int dy[] = {1, 0, -1, 0};
// // 预存10^0 mod7=1，10^1 mod7=3，10^2 mod7=2（因幸运值≤99，最多2位）
// int pow10_mod7[] = {1, 3, 2};

// int n, m, k;
// int grid[10][10];  // 地图幸运值
// int ans = 0;       // 满足条件的路径数

// // 计算数字的位数（1或2）
// int get_len(int num) {
//     return num >= 10 ? 2 : 1;
// }

// // DFS参数：x,y=当前坐标，dir=当前方向，used=访问掩码，rem=当前余数，cnt=已用转向卡
// void dfs(int x, int y, int dir, long long used, int rem, int cnt) {
//     // 若当前余数为0，路径有效，计数+1
//     if (rem == 0) {
//         ans++;
//     }

//     // 尝试四个方向移动
//     for (int new_dir = 0; new_dir < 4; new_dir++) {
//         int nx = x + dx[new_dir];
//         int ny = y + dy[new_dir];
//         // 1. 坐标合法
//         if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
//         // 2. 格子未被访问（used的第(nx*m + ny)位是否为0）
//         if (used & (1LL << (nx * m + ny))) continue;
//         // 3. 转向卡是否足够（方向不同则cnt+1 ≤k）
//         int new_cnt = cnt + (new_dir != dir ? 1 : 0);
//         if (new_cnt > k) continue;

//         // 计算新的余数
//         int val = grid[nx][ny];
//         int len = get_len(val);
//         int val_mod7 = val % 7;
//         int new_rem = (rem * pow10_mod7[len] + val_mod7) % 7;
//         // 新的访问掩码（标记nx,ny已访问）
//         long long new_used = used | (1LL << (nx * m + ny));

//         // 递归搜索新状态
//         dfs(nx, ny, new_dir, new_used, new_rem, new_cnt);
//     }
// }

// int main() {
//     // 输入处理
//     scanf("%d %d %d", &n, &m, &k);
//     for (int i = 0; i < n; i++) {
//         for (int j = 0; j < m; j++) {
//             scanf("%d", &grid[i][j]);
//         }
//     }

//     // 起点初始化：(0,0)，方向0（右），used=1<<0（标记(0,0)已访问），rem=grid[0][0]%7，cnt=0
//     int start_val = grid[0][0];
//     int start_rem = start_val % 7;
//     dfs(0, 0, 0, 1LL << 0, start_rem, 0);

//     // 输出结果
//     printf("%d\n", ans);
//     return 0;
// }
#include <stdio.h>
#include <string.h>

// 字符串反转函数（原地反转）
void reverse_str(char *str) {
    int len = strlen(str);
    int start = 0, end = len - 1;
    while (start <= end) {
        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        start++;
        end--;
    }
}

int main() {
    char s[1001], copy[1001];  // s存原字符串，copy用于strtok分割（strtok会修改原字符串）
    scanf("%s", s);
    strcpy(copy, s);  // 复制原字符串，避免strtok修改原串

    char res[1001] = "";  // 结果字符串
    char *token;          // strtok返回的当前段指针
    int part_idx = 0;     // 标记当前是第几段（0:www, 1~n:中间段, n+1:后缀）

    // 按'.'分割字符串（strtok第一次调用传原串，后续传NULL）
    token = strtok(copy, ".");
    while (token != NULL) {
        if (part_idx == 0) {
            // 第0段：www，直接拼接，不反转
            strcat(res, token);
            strcat(res, ".");  // 拼接分隔符
        } else if (strcmp(token, "cn") == 0 || strcmp(token, "com") == 0) {
            // 最后一段：后缀（cn/com），拼接，不反转
            strcat(res, token);
        } else {
            // 中间段：反转后拼接
            reverse_str(token);
            strcat(res, token);
            strcat(res, ".");  // 拼接分隔符
        }
        part_idx++;
        token = strtok(NULL, ".");  // 继续分割下一段
    }

    // 输出结果
    printf("%s\n", res);
    return 0;
}